import axios from 'axios';
import { BASE_API_URL, API_PATHS } from '../config/proxy';
import langchainWebSocket from '../utils/langchainWebSocket';

// 创建axios实例
const api = axios.create({
  baseURL: BASE_API_URL,
  timeout: 30000,
  headers: {
    'Content-Type': 'application/json'
  }
});

// 响应拦截器
api.interceptors.response.use(
  response => response.data,
  error => {
    console.error('响应错误: ', error);
    return Promise.reject(error);
  }
);

// MCP Service API
export const mcpApi = {
  // 获取智能体状态
  getAgentStatus() {
    return api.get(API_PATHS.MCP.AGENT_STATUS);
  },
  
  // 处理用户意图
  processIntent(query) {
    const mockResponse = {
      answer: `模拟响应: "${query}" 的处理结果`,
      agentStatus: {
        '语音处理智能体': '空闲',
        '理解智能体': '空闲',
        '规划智能体': '空闲'
      }
    };
    
    try {
      // 尝试调用后端API
      return api.post(API_PATHS.MCP.PROCESS, { query })
        .catch(error => {
          console.warn('获取智能体状态API调用失败，使用本地模拟数据', error);
          return mockResponse;
        });
    } catch (error) {
      console.error('处理意图时出错:', error);
      return Promise.resolve(mockResponse);
    }
  },
  
  // 查询数据
  queryData(params) {
    return api.get(API_PATHS.MCP.QUERY, { params });
  }
};

// LangChain Service API
export const langChainApi = {
  // 处理自然语言查询
  processQuery(query) {
    // 直接请求后端接口
    try {
      return api.post('/langchain/query', { query })
        .catch(error => {
          console.warn('LangChain API调用失败，使用HTTP备用接口', error);
          return {
            answer: `无法处理您的查询: "${query}"，请稍后再试。`,
            success: false
          };
        });
    } catch (error) {
      console.error('处理查询时出错:', error);
      return Promise.resolve({
        answer: `处理查询时发生错误，请稍后再试。`,
        success: false
      });
    }
  },
  
  // 处理自然语言查询(使用REST API，不需要WebSocket)
  processQueryDirectly(query) {
    // 直接连接到后端服务器，绕过代理
    const backendUrl = 'http://localhost:8080/iff/api/langchain/query';
    
    return axios.post(backendUrl, { query }, {
      headers: {
        'Content-Type': 'application/json'
      }
    })
    .then(response => response.data)
    .catch(error => {
      console.error('直接请求LangChain API失败:', error);
      return {
        answer: `无法连接到LangChain服务: "${query}"，请检查服务是否可用。`,
        success: false
      };
    });
  },
  
  // 使用专用WebSocket处理查询
  async processQueryWithDirectWs(query) {
    try {
      // 尝试连接WebSocket
      if (!langchainWebSocket.isConnected()) {
        await langchainWebSocket.connect();
      }
      
      // 发送查询
      const response = await langchainWebSocket.sendQuery(query);
      return {
        answer: response.content,
        success: true
      };
    } catch (error) {
      console.error('使用WebSocket查询失败:', error);
      
      // 如果WebSocket失败，尝试使用直接HTTP调用
      console.log('WebSocket查询失败，尝试HTTP调用...');
      return this.processQueryDirectly(query);
    }
  },
  
  // 处理自然语言查询(WebSocket版本)
  processQueryWs(query, wsService) {
    // 尝试先用专用WebSocket处理
    return this.processQueryWithDirectWs(query)
      .then(response => {
        if (response.success) {
          return {
            type: 'query_response',
            content: response.answer,
            timestamp: new Date().getTime()
          };
        }
        
        // 如果专用WebSocket失败，尝试普通WebSocket
        // 发送查询到WebSocket服务器
        const destination = wsService.getDestination('SEND_MESSAGE');
        
        wsService.send(destination, {
          type: 'query',
          content: query,
          timestamp: new Date().getTime()
        });
        
        // 返回一个Promise，等待WebSocket响应
        return new Promise((resolve) => {
          // 首先设置超时，避免无限等待
          const timeout = setTimeout(() => {
            window.removeEventListener('ws:chat', listener);
            // 超时后使用HTTP接口作为备用
            console.warn('WebSocket响应超时，使用HTTP备用接口');
            this.processQueryDirectly(query)
              .then(response => {
                resolve({
                  type: 'query_response',
                  content: response.answer || '服务器没有返回有效响应',
                  timestamp: new Date().getTime()
                });
              });
          }, 10000); // 10秒超时
          
          // 注册一个一次性事件监听器
          const listener = (event) => {
            const response = event.detail;
            if (response && response.type === 'query_response') {
              // 清除超时
              clearTimeout(timeout);
              // 移除事件监听器
              window.removeEventListener('ws:chat', listener);
              resolve(response);
            }
          };
          
          // 添加事件监听器
          window.addEventListener('ws:chat', listener);
        });
      });
  },
  
  // 聊天对话
  chat(message) {
    return api.post('/langchain/chat', { message });
  }
};

// 语音服务API
export const voiceApi = {
  // 语音识别
  recognize(audioData) {
    return api.post(API_PATHS.VOICE.RECOGNIZE, audioData, {
      headers: {
        'Content-Type': 'audio/wav'
      }
    });
  },
  
  // 语音合成
  synthesize(text) {
    return api.post(API_PATHS.VOICE.SYNTHESIZE, { text }, {
      responseType: 'blob'
    });
  }
};

export default {
  mcpApi,
  langChainApi,
  voiceApi
}; 